/**
 * 登录验证模块
 * 统一处理所有登录验证和权限检查逻辑
 */

import { getToken, isTokenExpired, getUserInfo } from './storage.js'
import { USER_ROLES, LOGIN_STATUS } from './constants.js'

// 错误消息常量
export const ERROR_MESSAGES = {
    EMAIL_REQUIRED: '请输入邮箱',
    INVALID_EMAIL: '请输入有效的邮箱地址',
    PASSWORD_REQUIRED: '请输入密码',
    PASSWORD_TOO_SHORT: '密码长度至少为8位',
    NAME_REQUIRED: '请输入姓名',
    CONFIRM_PASSWORD_REQUIRED: '请确认密码',
    PASSWORD_MISMATCH: '两次输入的密码不一致',
    AGREE_TERMS_REQUIRED: '请同意服务条款和隐私政策'
};

/**
 * 验证登录表单
 * @param {object} form - 登录表单数据
 * @returns {object} 错误信息对象
 */
export function validateLoginForm(form) {
    const errors = {};
    if (!form.email) {
        errors.email = ERROR_MESSAGES.EMAIL_REQUIRED;
    } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(form.email)) {
        errors.email = ERROR_MESSAGES.INVALID_EMAIL;
    }
    if (!form.password) {
        errors.password = ERROR_MESSAGES.PASSWORD_REQUIRED;
    } else if (form.password.length < 8) {
        errors.password = ERROR_MESSAGES.PASSWORD_TOO_SHORT;
    }
    return errors;
}

/**
 * 验证注册表单
 * @param {object} form - 注册表单数据
 * @returns {object} 错误信息对象
 */
export function validateRegisterForm(form) {
    const errors = {};
    if (!form.name) {
        errors.name = ERROR_MESSAGES.NAME_REQUIRED;
    }
    if (!form.email) {
        errors.email = ERROR_MESSAGES.EMAIL_REQUIRED;
    } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(form.email)) {
        errors.email = ERROR_MESSAGES.INVALID_EMAIL;
    }
    if (!form.password) {
        errors.password = ERROR_MESSAGES.PASSWORD_REQUIRED;
    } else if (form.password.length < 8) {
        errors.password = ERROR_MESSAGES.PASSWORD_TOO_SHORT;
    }
    if (!form.confirmPassword) {
        errors.confirmPassword = ERROR_MESSAGES.CONFIRM_PASSWORD_REQUIRED;
    } else if (form.confirmPassword !== form.password) {
        errors.confirmPassword = ERROR_MESSAGES.PASSWORD_MISMATCH;
    }
    return errors;
}

/**
 * 检查用户是否已登录
 * @param {boolean} redirect - 未登录时是否跳转登录页
 * @returns {boolean} 是否已登录
 */
export const checkLoginStatus = (redirect = true) => {
  const token = getToken()
  
  if (!token) {
    if (redirect) {
      uni.navigateTo({
        url: '/pages/login/login'
      })
    }
    return false
  }
  
  if (isTokenExpired()) {
    if (redirect) {
      uni.showToast({
        title: '登录已过期，请重新登录',
        icon: 'none'
      })
      uni.navigateTo({
        url: '/pages/login/login'
      })
    }
    return false
  }
  
  return true
}

/**
 * 获取当前登录状态
 * @returns {string} 登录状态
 */
export const getLoginStatus = () => {
  const token = getToken()
  
  if (!token) {
    return LOGIN_STATUS.LOGGED_OUT
  }
  
  if (isTokenExpired()) {
    return LOGIN_STATUS.EXPIRED
  }
  
  return LOGIN_STATUS.LOGGED_IN
}

/**
 * 检查用户是否为管理员
 * @returns {boolean} 是否为管理员
 */
export const checkAdminRole = () => {
  const userInfo = getUserInfo()
  return userInfo?.role === USER_ROLES.ADMIN || 
         userInfo?.role === USER_ROLES.SUPER_ADMIN
}

/**
 * 检查用户是否为超级管理员
 * @returns {boolean} 是否为超级管理员
 */
export const checkSuperAdminRole = () => {
  const userInfo = getUserInfo()
  return userInfo?.role === USER_ROLES.SUPER_ADMIN
}

/**
 * 检查用户是否具有指定角色
 * @param {string|string[]} roles - 角色或角色数组
 * @returns {boolean} 是否具有指定角色
 */
export const checkUserRole = (roles) => {
  const userInfo = getUserInfo()
  if (!userInfo?.role) return false
  
  const roleList = Array.isArray(roles) ? roles : [roles]
  return roleList.includes(userInfo.role)
}

/**
 * 检查用户权限
 * @param {string} permission - 权限标识
 * @returns {boolean} 是否具有权限
 */
export const checkUserPermission = (permission) => {
  const userInfo = getUserInfo()
  const permissions = userInfo?.permissions || []
  return permissions.includes(permission)
}

/**
 * 检查用户是否具有任意权限
 * @param {string[]} permissions - 权限列表
 * @returns {boolean} 是否具有任意权限
 */
export const checkAnyPermission = (permissions) => {
  const userInfo = getUserInfo()
  if (!userInfo?.permissions) return false
  
  return permissions.some(permission => 
    userInfo.permissions.includes(permission)
  )
}

/**
 * 检查用户是否具有所有权限
 * @param {string[]} permissions - 权限列表
 * @returns {boolean} 是否具有所有权限
 */
export const checkAllPermissions = (permissions) => {
  const userInfo = getUserInfo()
  if (!userInfo?.permissions) return false
  
  return permissions.every(permission => 
    userInfo.permissions.includes(permission)
  )
}

/**
 * 验证token有效性
 * @returns {Promise<boolean>} token是否有效
 */
export const validateToken = async () => {
  try {
    const token = getToken()
    if (!token) return false
    
    // 这里可以添加token验证的API调用
    // const response = await api.validateToken(token)
    // return response.valid
    
    return !isTokenExpired()
  } catch (error) {
    console.error('验证token失败:', error)
    return false
  }
}

/**
 * 获取当前用户角色
 * @returns {string} 用户角色
 */
export const getCurrentUserRole = () => {
  const userInfo = getUserInfo()
  return userInfo?.role || USER_ROLES.USER
}

/**
 * 获取当前用户权限列表
 * @returns {string[]} 权限列表
 */
export const getCurrentUserPermissions = () => {
  const userInfo = getUserInfo()
  return userInfo?.permissions || []
}

/**
 * 操作前验证（通用验证函数）
 * @param {string} operationName - 操作名称
 * @returns {boolean} 是否通过验证
 */
export const validateBeforeOperation = (operationName = '操作') => {
  try {
    // 检查登录状态
    if (!checkLoginStatus(false)) {
      uni.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      })
      return false
    }
    
    // 检查token有效性
    if (isTokenExpired()) {
      uni.showToast({
        title: '登录已过期，请重新登录',
        icon: 'none',
        duration: 2000
      })
      return false
    }
    
    return true
  } catch (error) {
    console.error(`${operationName}验证失败:`, error)
    uni.showToast({
      title: `${operationName}失败，请重试`,
      icon: 'none',
      duration: 2000
    })
    return false
  }
}

/**
 * 检查用户权限（旧版兼容）
 * @param {string} requiredRole - 需要的角色
 * @param {boolean} redirectOnFail - 验证失败时是否跳转
 * @returns {boolean} 是否具有权限
 */
export const checkUserPermissionLegacy = (requiredRole = 'admin', redirectOnFail = true) => {
  try {
    // 检查登录状态
    if (!checkLoginStatus(false)) {
      if (redirectOnFail) {
        uni.navigateTo({
          url: '/pages/login/login'
        })
      }
      return false
    }
    
    // 检查用户角色
    const userInfo = getUserInfo()
    if (!userInfo || userInfo.role !== requiredRole) {
      if (redirectOnFail) {
        uni.showToast({
          title: '权限不足',
          icon: 'none',
          duration: 2000
        })
      }
      return false
    }
    
    return true
  } catch (error) {
    console.error('权限检查失败:', error)
    return false
  }
}